The invention relates to the field of client/server (also known as xe2x80x9cdistributedxe2x80x9d) computing, where one computing device (xe2x80x9cthe clientxe2x80x9d) requests another computing device (xe2x80x9cthe serverxe2x80x9d) to perform part of the client""s work. The client and server can also be both located on the same physical computing device.
Client/server computing has become more and more important over the past few years in the information technology world. This type of distributed computing allows one machine to delegate some of its work to another machine that might be, for example, better suited to perform that work. For example, the server could be a high-powered computer running a database program managing the storage of a vast amount of data, while the client is simply a desktop personal computer (PC) which requests information from the database to use in one of its local programs.
The benefits of client/server computing have been even further enhanced by the use of a well-known computer programming technology called object-oriented programming (OOP), which allows the client and server to be located on different (heterogeneous) xe2x80x9cplatformsxe2x80x9d. A platform is a combination of the specific hardware/software/operating system/communication protocol which a machine uses to do its work. OOP allows the client application program and server application program to operate on their own platforms without worrying how the client application""s work requests will be communicated and accepted by the server application. Likewise, the server application does not have to worry about how the OOP system will receive, translate and send the server application""s processing results back to the requesting client application.
Details of how OOP techniques have been integrated with heterogeneous client/server systems are explained in U.S. Pat. No. 5,440,744 and European Patent Published Application No. EP 0 677,943 A2. These latter two publications are hereby incorporated by reference. However, an example of the basic architecture will be given below for contextual understanding of the invention""s environment.
As shown in FIG. 1, the client computer 10 (which could, for example, be a personal computer having the IBM OS/2 operating system installed thereon) has an application program 40 running on its operating system (xe2x80x9cIBMxe2x80x9d and xe2x80x9cOS/2xe2x80x9d are trademarks of the International Business Machines corporation). The application program 40 will periodically require work to be performed on the server computer 20 and/or data to be returned from the server 20 for subsequent use by the application program 40. The server computer 20 can be, for example, a high-powered mainframe computer running on IBM""s MVS operating system (xe2x80x9cMVSxe2x80x9d is also a trademark of the IBM corp.). For the purposes of the present invention it is irrelevant whether the requests for communications services to be carried out by the server are instigated by user interaction with the first application program 40, or whether the application program 40 operates independently of user interaction and makes the requests automatically during the running of the program.
When the client computer 10 wishes to make a request for the server computer 20""s services, the first application program 40 informs the first logic means 50 of the service required. It may for example do this by sending the first logic means the name of a remote procedure along with a list of input and output parameters. The first logic means 50 then handles the task of establishing the necessary communications with the second computer 20 with reference to definitions of the available communications services stored in the storage device 60. All the possible services are defined as a cohesive framework of object classes 70, these classes being derived from a single object class. Defining the services in this way gives rise to a great number of advantages in terms of performance and reusability.
To establish the necessary communication with the server 20, the first logic means 50 determines which object class in the framework needs to be used, and then creates an instance of that object at the server, a message being sent to that object so as to cause that object to invoke one of its methods. This gives rise to the establishment of the connection with the server computer 20 via the connection means 80, and the subsequent sending of a request to the second logic means 90.
The second logic means 90 then passes the request on to the second application program 100 (hereafter called the service application) running on the server computer 20 so that the service application 100 can perform the specific task required by that request, such as running a data retrieval procedure. Once this task has been completed the service application may need to send results back to the first computer 10. The server application 100 interacts with the second logic means 90 during the performance of the requested tasks and when results are to be sent back to the first computer 10. The second logic means 90 establishes instances of objects, and invokes appropriate methods of those objects, as and when required by the server application 100, the object instances being created from the cohesive framework of object classes stored in the storage device 110.
Using the above technique, the client application program 40 is not exposed to the communications architecture. Further the service application 100 is invoked through the standard mechanism for its environment; it does not know that it is being invoked remotely.
The Object Management Group (OMG) is an international consortium of organizations involved in various aspects of client/server computing on heterogeneous platforms with distributed objects as is shown in FIG. 1. The OMG has set forth published standards by which client computers (e.g. 10) communicate (in OOP form) with server machines (e.g. 20). As part of these standards, an Object Request Broker (called CORBAxe2x80x94the Common Object Request Broker Architecture) has been defined, which provides the object-oriented bridge between the client and the server machines. The ORB decouples the client and server applications from the object oriented implementation details, performing at least part of the work of the first and second logic means 50 and 90 as well as the connection means 80.
As part of the CORBA software structure, the OMG has set forth standards related to xe2x80x9ctransactionsxe2x80x9d and these standards are known as the OTS or Object Transaction Service. See, e.g., CORBA Object Transaction Service Specification 1.0, OMG Document 94.8.4. Computer implemented transaction processing systems are used for critical business tasks in a number of industries. A transaction defines a single unit of work that must either be fully completed or fully purged without action. For example, in the case of a bank automated teller machine from which a customer seeks to withdraw money, the actions of issuing the money, reducing the balance of money on hand in the machine and reducing the customer""s bank balance must all occur or none of them must occur. Failure of one of the subordinate actions would lead to inconsistency between the records and the actual occurrences.
Distributed transaction processing involves a transaction that affects resources at more than one physical or logical location. In the above example, a transaction affects resources managed at the local automated teller device as well as bank balances managed by a bank""s main computer. Such transactions involve one particular client computer (e.g, 10) communicating with one particular server computer (e.g., 20) over a series of client requests which are processed by the server. The OMG""s OTS is responsible for coordinating these distributed transactions.
Usually, an application running on a client process begins a transaction which may involve calling a plurality of different servers, each of which will initiate a server process to make changes to its local database according to the instructions contained in the transaction. The transaction finishes by either committing the transaction (and thus all servers finalize the changes to their local databases) or aborting the transaction (and thus all servers xe2x80x9crollbackxe2x80x9d or ignore the changes to their local databases). To communicate with the servers during the transaction (e.g., instructing them to either commit or abort their part in the transaction) one of the processes involved must maintain state data for the transaction. This usually involves the process to set up a series of transaction state objects, one of which is a Coordinator object which coordinates the transaction with respect to the various servers.
A conventional implementation of the OTS, which was developed by the International Business Machines Corporation and included in its Component Broker Series (a trademark of the IBM Corp.) product announced in May of 1997, is shown in FIG. 2. A client process 21 which wants to begin a transaction (e.g., to withdraw money from a bank account) needs to locate a process which is capable of creating and holding the transaction objects that will maintain the state of the transaction. As the modern tendency is to create clients that are xe2x80x9cthinxe2x80x9d (and thus have only the minimum functionality), the client process 21 will usually not be able to maintain the transaction objects locally and must look for a server process for this purpose.
According to this prior art approach, the OTS (or another service, such as the CORBA Lifecycle service) locates a server process on which to create the transaction state objects (which include the Coordinator object 223, Control object 221 and Terminator object 222). The same server process (server A process 22 in FIG. 2) is always chosen according to this prior art. Upon locating the server A process 22, client process 21 sends (arrow with encircled number 1) a message to server A process 22 to instruct server A process 22 to create the transaction state objects. The Control object 221 (known in the OTS as CosTransactions::Control) provides access to the other two transaction state objects. The Terminator object 222 (known in the OTS as CosTransactions::Terminator) is used to end the transaction. The Coordinator object 223 (known in the OTS as CosTransactions::Coordinator) maintains a list, in local storage 225, of resource objects (such as bank account objects 224, 231) (known in the OTS as CosTransactions::Resource) that have made updates to their respective data during the transaction. This list is required so that the Coordinator object 223 can consistently call them at the end of the transaction to commit their transactional changes (make their local data changes final) or rollback such changes (bring the local data back to the state it was in before the transaction started). A rollback would be necessary, for example, where the transaction could not finish properly because one of the resources was not working properly.
Server A process 22 then creates the transaction state objects (221, 222, 223) and sends a reply (arrow with encircled number 2) containing the transaction context to client 21. Client 21 then sends a debit bank account command (arrow with encircled number 3) to server B process 23 (the process containing the bank account object 231 which the client process 21 wishes to withdraw money from). This latter command carries with it the transaction context supplied to the client 21 by the server A process 22. In this way, the bank account object 231 in process 23 can register itself (arrow with encircled number 4) with the coordinator object 223 in process 22 so that the bank account object 231 can be commanded (arrow with encircled number 5) to commit or rollback by the coordinator object 223 at the end of the transaction.
In the above operation, when the coordinator object 223 is created along with the other transaction state objects 221 and 222, the coordinator object 223 must log information about itself and the transaction it represents in local storage 225, so that the transaction will be recoverable in case of a failure which temporarily prevents the server A process 22 from continuing with the transaction.
There are many transactions which start and finish within the same server process (server A process 22), and which do not involve the need for a resource to update its local data. For these types of transactions, it is a server process that actually begins the transaction (rather than the client process as discussed above). For example, a client process 21 operating within an automated teller machine (ATM) is executing on behalf of a bank account holder who merely wishes to obtain the balance of his bank account (which is represented in FIG. 2 by Bank Account object 224). The client process 21 sends a balance enquiry command to a server process 22 which contains the bank account object 224 which the client wishes to check the balance of. Accordingly, the server process 22 would then begin the transaction by creating the three transaction state objects 221, 222 and 223. The Coordinator object 223 access local storage 225 in order to log-in the transaction to make it recoverable. The transaction proceeds to access the Bank Account object 224, read its balance and return it to the client process 21. The transaction then ends by using the Terminator object 222 to destroy the other transaction state objects 221 and 223 and then the Terminator object 222 destroys itself.
In these latter types of transactions, the prior art implementation is inefficient. Since no additional server processes had to be called and no local resources have made updates to local data throughout the whole transaction, the Coordinator""s functions of logging the transaction to storage 225 has been unnecessary. Further, the very fact that the Coordinator had to be instantiated has taken up some processing power which could be better spent elsewhere in the server process 22.
According to a first aspect, the present invention provides a server processing apparatus for use in a client/server computing system which carries out transactions, the apparatus having: a means for receiving a command instructing the server processing apparatus to carry out a step of a transaction; a means for beginning the transaction; and a means for determining whether a predetermined triggering event has occurred during the carrying out of the transaction, and only if the triggering event has occurred, creating a means for coordinating the transaction with respect to a plurality of elements that are involved in carrying out the transaction.
Preferably, the triggering event is the receipt of a request to update a local resource as part of the transaction. Further preferably, the triggering event is the receipt of a request to invoke an additional server processing apparatus as part of the transaction.
In the preferred embodiment, the means for coordinating is a Coordinator object, as defined by the Common Object Request Broker Architecture""s Object Transaction Service (CORBA""s OTS), and the elements that are involved in carrying out the transaction are local resources or a remote server process. Preferably, the means for coordinating involves commanding each the transactionally involved local resources and/or remote server processes to commit their respective transactional activity.
According to a second aspect, the invention provides a method of carrying out the functionality of the server described above in the first aspect.
According to a third aspect, the invention provides a computer program product stored on a computer readable storage medium for, when run on a computer, carrying out the functionality of the first aspect.
Thus, with the present invention, a highly efficient use of server processor cycles is used as the Coordinator object is not instantiated until a triggering event occurs which requires the use of the Coordinator object. Thus, if a transaction does not produce such a triggering event, the Coordinator object will not be instantiated, thus saving on the server""s processor cycles. Also, if the Coordinator object is not instantiated, this saves on writes to local storage that would otherwise occur when the Coordinator object logs the existence of the transaction for recovery purposes when the Coordinator object is first instantiated.